package cn.xzc.job.util;

import java.util.Arrays;

/**
 * @author 熊志聪
 * @Classname ArrayUtil
 * @Description 对array的操作
 * @Date 2024/2/16 21:03
 */
public class ArrayUtil {
    public static <T> boolean isEmpty(T[] array) {
        return !isNotEmpty(array);
    }

    /**
     * 引用类型数组判断是否为空
     *
     * @param array 引用类型数组
     * @param <T>   对应的引用类型
     * @return true:非空,false:空
     */
    public static <T> boolean isNotEmpty(T[] array) {
        return array != null && array.length > 0;
    }


    /**
     * 判断两个数组是否是相同的
     * @param o1 数组1
     * @param o2 数组2
     * @return 数组相同返回true,否则返回false
     */
    public static boolean arrayEquals(Object o1, Object o2) {
        //null==null true
        if (o1==o2) {
            return true;
        }
        if (o1 == null || o2 == null) {
            return false;
        }
        //存在非数组元素
        if (!isArray(o1)||!isArray(o2)) {
            return false;
        }
        if (o1 instanceof boolean[] && o2 instanceof boolean[]) {
            return Arrays.equals((boolean[]) o1, (boolean[]) o2);
        }
        if (o1 instanceof byte[] && o2 instanceof byte[]) {
            return Arrays.equals((byte[]) o1, (byte[]) o2);
        }
        if (o1 instanceof short[] && o2 instanceof short[]) {
            return Arrays.equals((short[]) o1, (short[]) o2);
        }
        if (o1 instanceof char[] && o2 instanceof char[]) {
            return Arrays.equals((char[]) o1, (char[]) o2);
        }
        if (o1 instanceof int[] && o2 instanceof int[]) {
            return Arrays.equals((int[]) o1, (int[]) o2);
        }
        if (o1 instanceof float[] && o2 instanceof float[]) {
            return Arrays.equals((float[]) o1, (float[]) o2);
        }
        if (o1 instanceof long[] && o2 instanceof long[]) {
            return Arrays.equals((long[]) o1, (long[]) o2);
        }
        if (o1 instanceof double[] && o2 instanceof double[]) {
            return Arrays.equals((double[]) o1, (double[]) o2);
        }
        if (o1 instanceof Object[] && o2 instanceof Object[]) {
            return Arrays.deepEquals((Object[]) o1, (Object[]) o2);
        }
        return false;
    }

    /**
     * 数组或集合转String
     *
     * @param obj 集合或数组对象
     * @return 数组字符串，与集合转字符串格式相同
     */
    public static String toString(Object obj){
        if ((obj == null)) {
            return null;
        }
        if (obj instanceof boolean[]) {
            return Arrays.toString((boolean[]) obj);
        }
        if (obj instanceof byte[] ) {
            return Arrays.toString((byte[]) obj);
        }
        if (obj instanceof short[]) {
            return Arrays.toString((short[]) obj);
        }
        if (obj instanceof char[]) {
            return Arrays.toString((char[]) obj);
        }
        if (obj instanceof int[]) {
            return Arrays.toString((int[]) obj);
        }
        if (obj instanceof float[] ) {
            return Arrays.toString((float[]) obj);
        }
        if (obj instanceof long[] ) {
            return Arrays.toString((long[]) obj);
        }
        if (obj instanceof double[] ) {
            return Arrays.toString((double[]) obj);
        }
        if (isArray(obj)) {
            try {
                return Arrays.deepToString((Object[]) obj);
            } catch (Exception ignore) {
            }
        }
        return obj.toString();
    }



    /**
     * 判断该对象是否为数组
     *
     * @param arrayObj 需要判断的对象
     * @return true:是数组,false:否
     */
    public static boolean isArray(Object arrayObj) {
        return arrayObj != null && arrayObj.getClass().isArray();
    }

}
